package com.lightsh.file;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Collections;
import java.util.LinkedList;

import android.util.Log;


/**
 * 文件操作的工具类
 * @author Shu
 *
 */
public class FileUtils {
	
	private static final String TAG = "FileUtils";
	private static final boolean DEBUG_PROCESS = false;
	
	/**
	 * 限制文件夹里面文件的大小，如果超出大小,则删除创建时间较长的文件
	 * 注：考虑效率原因,暂不会进行文件夹的嵌套统计。即只计算根文件夹内的文件，而不管文件夹
	 * @param path
	 * @param clearSize			如果文件夹内容超出maxSize大小，则将文件夹的内容减少到该值
	 * @param maxSize			使用该值判断是否需要清理
	 * @param endFiler 			以该字符结尾的软件将不会被删除(为了不删除临时文件),传入null表示不需要过滤
	 */
	public static final void limitPathFileSize(String path, long clearSize, long maxSize, String endFilter){
		File desPath = new File(path);
		if(!desPath.exists() || !desPath.isDirectory()){
			return;
		}
		
		long totalSize = 0;
		File[] files = desPath.listFiles();
		for(File file : files){
			if(file.isFile() ){
				totalSize += file.length();
			}
		}
		if(totalSize > maxSize){			
			class Tuple implements Comparable<Tuple>{
				Tuple(long size, long lastModify, String fullPath){
					this.size = size;
					this.lastModify = lastModify;
					this.fullPath = fullPath;
				}
				long size;
				long lastModify;
				String fullPath;
				public int compareTo(Tuple another) {
					if(lastModify == another.lastModify){
						return 0;
					}else{
						if(lastModify < another.lastModify){
							return 1;
						}else{
							return -1;
						}
					}
				}
				public String toString(){
					return lastModify + "," + size + "," +  fullPath;
				}
			}
			// 进行清理
			LinkedList<Tuple> sizeModify = new LinkedList<Tuple>();
			for(File file : files){
				if(file.isFile()){
					sizeModify.add(new Tuple(file.length(), file.lastModified(), file.getAbsolutePath()));
				}
			}
			if(DEBUG_PROCESS){
				Log.e(TAG, "before sort:");
				for(Tuple tuple : sizeModify){
					Log.e(TAG, tuple.toString());
				}
			}
			Collections.sort(sizeModify);
			
			if(DEBUG_PROCESS){
				Log.e(TAG, "after sort:");
				for(Tuple tuple : sizeModify){
					Log.e(TAG, tuple.toString());
				}
			}
			
			int limitCount = 0;
			for(Tuple fileInfo : sizeModify){
				if(limitCount < clearSize){
					limitCount += fileInfo.size;
					if(limitCount  < clearSize){
						continue;
					}else{
						
					}
				}
				if(endFilter != null && fileInfo.fullPath.endsWith(endFilter)){
					if(DEBUG_PROCESS){
						Log.e(TAG, "not remove temp file: " + fileInfo.toString());
					}
					continue;
				}
				if(DEBUG_PROCESS){
					Log.e(TAG, "need to remove : " + fileInfo.toString());
				}
				new File(fileInfo.fullPath).delete();
			}
		}
	}
	
	/**
	 *  删除文件或者目录（目录可以非空）
	 * @param path
	 */
    public static final void removeFullPath(File path) {
    	if(path.exists()){
    		if (path.isDirectory()) {
    			// 如果时文件夹，先删除里面的所有文件
                File[] child = path.listFiles();
                if (child != null && child.length != 0) {   
                    for (int i = 0; i < child.length; i++) {   
                    	removeFullPath(child[i]);
                    }   
                }
            }
    		// 文件或者文件夹都需要在这里删除
            path.delete();
    	}
    }
    
    /**
     * 判断文件的路径是否存在，如果不存在则创建
     */
    public static final void createPathForFile(File desFile){
    	if(!desFile.exists()){
    		File parentPath = desFile.getParentFile();
    		if(parentPath != null && DEBUG_PROCESS){
    			Log.e(TAG, parentPath.getAbsolutePath() + ":" + desFile.getAbsolutePath());
    		}
    		if(parentPath != null && !parentPath.exists()){
    			parentPath.mkdirs();
    		}
    	}
    }
    /**
     * 创建新文件，包括创建路径
     */
    public static final boolean createNewFile(String fileFullPath){
    	return createNewFile(new File(fileFullPath));
    }
    /**
     * 创建新文件，包括创建路径
     */
    public static final boolean createNewFile(File file){
    	if(!file.exists()){
    		File parentPath = file.getParentFile();
    		if(parentPath != null && DEBUG_PROCESS){
    			Log.e(TAG, parentPath.getAbsolutePath() + ":" + file.getAbsolutePath());
    		}    		
    		if(parentPath != null){
    			if(!parentPath.exists()){
        			if(!parentPath.mkdirs()){
        				return false;
        			}
        		}
    		}
    		try {
				return file.createNewFile();
			} catch (IOException e) {
				e.printStackTrace();
				return false;
			}
    	}else{
    		return true;
    	}
    }
    
    
    /**
     * 移动一个文件,删除源文件
     *
     * @param srcFile
     * @param destFile
     * @return
     * @throws IOException
     */
	public static final boolean moveFileTo(File srcFile, File destFile) throws IOException {
		if(!destFile.exists()){
			destFile.createNewFile();
		}		
		boolean iscopy = copyFileTo(srcFile, destFile);
        if (!iscopy){
        	return false;
        }
        delFile(srcFile);
        return true;
	}
	
	/**
     * 拷贝一个文件,srcFile源文件，destFile目标文件
     *
     * @param path
     * @throws IOException
     */
    public static final boolean copyFileTo(File srcFile, File destFile) throws IOException {
            if (srcFile.isDirectory() || destFile.isDirectory()){
            	return false;
            }
            FileInputStream fis = new FileInputStream(srcFile);
            FileOutputStream fos = new FileOutputStream(destFile);
            int readLen = 0;
            byte[] buf = new byte[1024];
            while ((readLen = fis.read(buf)) != -1) {
                    fos.write(buf, 0, readLen);
            }
            fos.flush();
            fos.close();
            fis.close();
            return true;
    }
    /**
     * 删除一个文件
     *
     * @param file
     * @return
     */
    public static final boolean delFile(File file) {
            if (file.isDirectory()){
            	return false;
            }
            return file.delete();
    }
}
